package Modelo;

import Controlador.Controlador;
import Vista.Inicio;
import Utils.CoordUTM;
import Utils.Ficheros.FicheroDatos;
import Utils.Util;
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Component;
import java.awt.Insets;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Toolkit;
import java.util.Vector;
import javax.swing.border.Border;

public class Geomantes implements Border {

    private int[] datosEntrada; //Desplazamiento en pixeles (mirar bien)
    private float velocidad; //Velocidad actual
    private float distancia; //Distancia recorrida
    private double longitudAntigua, longitudActual, latitudAntigua, latitudActual;
    private double escala; //Relación metros/pixel actual
    private static Controlador controlador;
    private int nivelZoom; //Por defecto 17
    private String mapType; //Tipo de mapa: hybrid, terrain, satellite, roadmap
    private FicheroDatos coordenadas;
    private int despX; //Desplazamiento X en pixeles desde la posición inicial
    private int despY; //Desplazamiento Y en pixeles desde la posición inicial
    private int ancho; //Ancho de la pantalla
    private int alto;  //Alto de la pantalla
    private GoogleMaps googlemaps; //Variable de la clase GoogleMaps
    private ElementoGmaps[][] matrizGMaps; //Matriz de mapas GoogleMaps
    private ElementoGmaps[][] matrizMemoria; //Matriz de mapas en memoria
    private Color colorRuta1, colorRuta2, colorRuta3;

    public Geomantes() throws Exception {
        super();
        inicializarValores();
    }

    public void setColor1(Color a) {
        colorRuta1 = a;
    }

    public void setColor2(Color a) {
        colorRuta2 = a;
    }

    public void setColor3(Color a) {
        colorRuta3 = a;
    }

    public void setCoordenadas(FicheroDatos c) {
        coordenadas = c;
    }

    public FicheroDatos getCoordenadas() {
        return coordenadas;
    }

    public void setInfoFichero(FicheroDatos infolinea, int[] dE, float v, float d) {
        if (d >= 0) {
            distancia = distancia + d;
        }
        datosEntrada = dE;
        velocidad = v;
    }

    private boolean estaCompleta(ElementoGmaps[][] matriz) {
        int i = 0;
        boolean completa = true;
        while (completa && i < matriz.length) {
            int j = 0;
            while (completa && j < matriz.length) {
                if (matriz[i][j].getImagen() != null) {
                    j++;
                } else {
                    completa = false;
                }
            }
            i++;
        }
        return completa;
    }

    private void inicializarMemoria() {
        if (CalculosDatos.getNumFilas() == 0 && CalculosDatos.getNumColumnas() == 0) {
            matrizMemoria = new ElementoGmaps[1][1];
            matrizMemoria[0][0] = new ElementoGmaps();
            try {
                datosEntrada = CalculosDatos.calcular(coordenadas);
                String imagen = CalculosDatos.getRutaImagen() + CalculosDatos.getFicheroImagen() + CalculosDatos.getExtensionImagen();
                Image mapa = Toolkit.getDefaultToolkit().getImage(imagen);
                matrizMemoria[0][0].setImagen(mapa);
                CalculosDatos.setNumColumnas(1);
                CalculosDatos.setNumFilas(1);
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        } else {
            datosEntrada = CalculosDatos.calcular(coordenadas);
            matrizMemoria = new ElementoGmaps[CalculosDatos.getNumFilas()][CalculosDatos.getNumColumnas()];
            for (int i = 0; i < CalculosDatos.getNumFilas(); i++) {
                for (int j = 0; j < CalculosDatos.getNumColumnas(); j++) {
                    matrizMemoria[i][j] = new ElementoGmaps();
                }
            }

            for (int i = 0; i < CalculosDatos.getNumFilas(); i++) {
                for (int j = 0; j < CalculosDatos.getNumColumnas(); j++) {
                    try {
                        String imagen = CalculosDatos.getRutaImagen() + CalculosDatos.getFicheroImagen() + i + "_" + j + CalculosDatos.getExtensionImagen();
                        Image mapa = Toolkit.getDefaultToolkit().getImage(imagen);
                        matrizMemoria[i][j].setImagen(mapa);

                    } catch (Exception ex) {
                        ex.printStackTrace();
                    }
                }
            }
        }
    }

    private void paintMapasMemoria(Graphics g) {
        try {
            if (matrizMemoria == null) {
                inicializarMemoria();
            } else {
                if (estaCompleta(matrizMemoria)) {
                    for (int i = 0; i < CalculosDatos.getNumFilas(); i++) {
                        for (int j = 0; j < CalculosDatos.getNumColumnas(); j++) {
                            Image img = matrizMemoria[i][j].getImagen();
                            g.drawImage(
                                    img,
                                    (j * img.getWidth(null)) - datosEntrada[2] + ancho / 2,
                                    (i * img.getHeight(null)) - datosEntrada[3] + alto / 2,
                                    null);
                        }
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void inicializarGmaps() {
        matrizGMaps = new ElementoGmaps[3][3];
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                matrizGMaps[i][j] = new ElementoGmaps();
            }
        }
        try {
            matrizGMaps[1][1].setImagen(googlemaps.retrieveStaticImage(ancho, alto, coordenadas.getLatitud(), coordenadas.getLongitud(), nivelZoom, "png", mapType));
            matrizGMaps[1][1].setLongitud(coordenadas.getLongitud());
            matrizGMaps[1][1].setLatitud(coordenadas.getLatitud());
        } catch (Exception ex) {
            System.out.println("Google reintenta coger mapa");
            ex.printStackTrace();
        }

        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                if (i != 1 || j != 1) {
                    int difI = i - 1;
                    int difJ = j - 1;
                    try {
                        double[] latlon = Util.adjust(matrizGMaps[1][1].getLatitud(),
                                matrizGMaps[1][1].getLongitud(),
                                ancho * difJ, alto * difI, nivelZoom);
                        matrizGMaps[i][j].setImagen(googlemaps.retrieveStaticImage(ancho, alto,
                                latlon[1], latlon[0], nivelZoom, "png", mapType));
                        matrizGMaps[i][j].setLongitud(latlon[0]);
                        matrizGMaps[i][j].setLatitud(latlon[1]);
                    } catch (Exception ex) {
                        ex.printStackTrace();
                    }
                }
            }
        }
        despX = 0;
        despY = 0;
    }

    private void paintMapasGoogle(Graphics g) {
        try {
            if (matrizGMaps == null) {
                latitudAntigua = coordenadas.getLongitud();
                longitudAntigua = coordenadas.getLongitud();
                latitudActual = coordenadas.getLatitud();
                longitudActual = coordenadas.getLongitud();
                inicializarGmaps();
            } else {
                latitudAntigua = latitudActual;
                longitudAntigua = longitudActual;
                latitudActual = coordenadas.getLatitud();
                longitudActual = coordenadas.getLongitud();
                CoordUTM CoordUTMAntigua = Util.LLtoUTM(23, latitudAntigua, longitudAntigua); // origen
                CoordUTM CoordUTMActual = Util.LLtoUTM(23, latitudActual, longitudActual); // destino
                int incX = (int) (Math.floor(-(CoordUTMActual.getUTMEasting() - CoordUTMAntigua.getUTMEasting()) * (1 / escala) + 0.5d));
                int incY = (int) (Math.floor((CoordUTMActual.getUTMNorthing() - CoordUTMAntigua.getUTMNorthing()) * (1 / escala) + 0.5d));
                despY = despY + incY;
                despX = despX + incX;

                if (estaCompleta(matrizGMaps)) {
                    for (int i = 0; i < 3; i++) {
                        for (int j = 0; j < 3; j++) {
                            Image img = matrizGMaps[i][j].getImagen();
                            g.drawImage(
                                    img,
                                    (j - 1) * ancho + despX,
                                    (i - 1) * alto + despY,
                                    null);
                        }
                    }
                }
                // Si nos hemos salido de los margenes del mapa, recalculamos la matriz
                if ((Math.abs(despX) >= ancho / 2 || Math.abs(despY) >= alto / 2)) {
                    desplazaMapasGmaps();
                }
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    public void guardarMapas() {
        if (matrizGMaps != null) {
            controlador.guardarMapaGoogle(
                    3,
                    matrizGMaps,
                    googlemaps,
                    ancho,
                    alto);
        }
    }

    private void desplazaMapasGmaps() {
        int mitadAltura = matrizGMaps[0][0].getImagen().getHeight(null) / 2;
        int mitadAnchura = matrizGMaps[0][0].getImagen().getWidth(null) / 2;

        //Laterales
        //Se sale por la derecha
        if (despX < -mitadAnchura && despY > -mitadAltura && despY < mitadAltura) {
            despX = mitadAnchura - (Math.abs(despX) - mitadAnchura);
            double longitudIni = matrizGMaps[1][2].getLongitud();
            double latitudIni = matrizGMaps[1][2].getLatitud();
            for (int m = 0; m < 3; m++) {
                for (int n = 0; n < 2; n++) {
                    matrizGMaps[m][n].setImagen(matrizGMaps[m][n + 1].getImagen());
                    matrizGMaps[m][n].setLatitud(matrizGMaps[m][n + 1].getLatitud());
                    matrizGMaps[m][n].setLongitud(matrizGMaps[m][n + 1].getLongitud());
                }
            }

            for (int j = 0; j < 3; j++) {
                int difJ = j - 1;
                try {
                    double[] latlon = Util.adjust(latitudIni, longitudIni,
                            (mitadAnchura * 2), (mitadAltura * 2) * difJ, nivelZoom);
                    matrizGMaps[j][2].setImagen(googlemaps.retrieveStaticImage(mitadAnchura * 2, mitadAltura * 2,
                            latlon[1],
                            latlon[0], nivelZoom, "png", mapType));
                    matrizGMaps[j][2].setLatitud(latlon[1]);
                    matrizGMaps[j][2].setLongitud(latlon[0]);
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
        }

        //Se sale por la izquierda
        if (despX > mitadAnchura && despY > -mitadAltura && despY < mitadAltura) {
            despX = (despX - mitadAnchura) - mitadAnchura;
            double longitudIni = matrizGMaps[1][0].getLongitud();
            double latitudIni = matrizGMaps[1][0].getLatitud();
            for (int m = 0; m < 3; m++) {
                for (int n = 2; n > 0; n--) {
                    matrizGMaps[m][n].setImagen(matrizGMaps[m][n - 1].getImagen());
                    matrizGMaps[m][n].setLatitud(matrizGMaps[m][n - 1].getLatitud());
                    matrizGMaps[m][n].setLongitud(matrizGMaps[m][n - 1].getLongitud());
                }
            }
            for (int j = 0; j < 3; j++) {
                int difJ = j - 1;
                try {
                    double[] latlon = Util.adjust(latitudIni, longitudIni,
                            -(mitadAnchura * 2), (mitadAltura * 2) * difJ, nivelZoom);
                    matrizGMaps[j][0].setImagen(googlemaps.retrieveStaticImage(mitadAnchura * 2, mitadAltura * 2,
                            latlon[1],
                            latlon[0], nivelZoom, "png", mapType));
                    matrizGMaps[j][0].setLatitud(latlon[1]);
                    matrizGMaps[j][0].setLongitud(latlon[0]);
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
        }
        //Se sale por arriba
        if (despX > -mitadAnchura && despX < mitadAnchura && despY < -mitadAltura) {
            despY = mitadAltura - (Math.abs(despY) - mitadAltura);

            double longitudIni = matrizGMaps[2][1].getLongitud();
            double latitudIni = matrizGMaps[2][1].getLatitud();
            for (int m = 0; m < 2; m++) {
                for (int n = 0; n < 3; n++) {
                    matrizGMaps[m][n].setImagen(matrizGMaps[m + 1][n].getImagen());
                    matrizGMaps[m][n].setLatitud(matrizGMaps[m + 1][n].getLatitud());
                    matrizGMaps[m][n].setLongitud(matrizGMaps[m + 1][n].getLongitud());
                }
            }
            for (int j = 0; j < 3; j++) {
                int difJ = j - 1;
                try {
                    double[] latlon = Util.adjust(latitudIni, longitudIni,
                            (mitadAnchura * 2) * difJ, (mitadAltura * 2), nivelZoom);
                    matrizGMaps[2][j].setImagen(googlemaps.retrieveStaticImage(mitadAnchura * 2, mitadAltura * 2,
                            latlon[1],
                            latlon[0], nivelZoom, "png", mapType));
                    matrizGMaps[2][j].setLatitud(latlon[1]);
                    matrizGMaps[2][j].setLongitud(latlon[0]);
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
        }
        //Se sale por abajo
        if (despX > -mitadAnchura && despX < mitadAnchura && despY > mitadAltura) {
            despY = (despY - mitadAltura) - mitadAltura;
            double longitudIni = matrizGMaps[0][1].getLongitud();
            double latitudIni = matrizGMaps[0][1].getLatitud();
            for (int m = 2; m > 0; m--) {
                for (int n = 0; n < 3; n++) {
                    matrizGMaps[m][n].setImagen(matrizGMaps[m - 1][n].getImagen());
                    matrizGMaps[m][n].setLatitud(matrizGMaps[m - 1][n].getLatitud());
                    matrizGMaps[m][n].setLongitud(matrizGMaps[m - 1][n].getLongitud());
                }
            }
            for (int j = 0; j < 3; j++) {
                int difJ = j - 1;
                try {
                    double[] latlon = Util.adjust(latitudIni, longitudIni,
                            (mitadAnchura * 2) * difJ, -(mitadAltura * 2), nivelZoom);
                    matrizGMaps[0][j].setImagen(googlemaps.retrieveStaticImage(mitadAnchura * 2, mitadAltura * 2,
                            latlon[1],
                            latlon[0], nivelZoom, "png", mapType));
                    matrizGMaps[0][j].setLatitud(latlon[1]);
                    matrizGMaps[0][j].setLongitud(latlon[0]);
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
        }
    }

    /**
     * Metodo que dibuja por pantalla un fondo que se mostrarÃ¡ por debajo del mapa
     * @param g objeto de tipo Graphics
     */
    private void paintNotFound(Graphics g) {
        if (!controlador.getModoMapas()) {
            g.clearRect(0, 0, ancho, alto);
        }
    }

    private void paintRuta(Graphics g2) {
        if (controlador.getModoGrabacion() && controlador.getMostrarRuta()) {
            Graphics2D g = (Graphics2D) g2;
            g.setColor(new Color(0x00ff00));
            if (controlador.getVectorRuta().size() > 0) {
                g.setColor(new Color(255, 0, 0));
                g.drawOval(
                        ancho / 2 - datosEntrada[2] + ((int[]) controlador.getVectorRuta().elementAt(0))[2] - 6,
                        alto / 2 - datosEntrada[3] + ((int[]) controlador.getVectorRuta().elementAt(0))[3] - 6, 10, 10);
                g.fillOval(ancho / 2 - datosEntrada[2] + ((int[]) controlador.getVectorRuta().elementAt(0))[2] - 6,
                        alto / 2 - datosEntrada[3] + ((int[]) controlador.getVectorRuta().elementAt(0))[3] - 6, 10, 10);
            }

            for (int i = 0; i < controlador.getVectorRuta().size() - 1; i++) {
                int xA = ((int[]) controlador.getVectorRuta().elementAt(i))[2];
                int yA = ((int[]) controlador.getVectorRuta().elementAt(i))[3];

                int xB = ((int[]) controlador.getVectorRuta().elementAt(i + 1))[2];
                int yB = ((int[]) controlador.getVectorRuta().elementAt(i + 1))[3];

                g.setStroke(new BasicStroke(4.0f));
                g.setColor(colorRuta2);

                g.drawLine(
                        (ancho / 2 - datosEntrada[2]) + xA,
                        (alto / 2 - datosEntrada[3]) + yA,
                        (ancho / 2 - datosEntrada[2]) + xB,
                        (alto / 2 - datosEntrada[3]) + yB);

                g.setColor(colorRuta1);
                g.setStroke(new BasicStroke(2.0f));
                g.drawLine(
                        (ancho / 2 - datosEntrada[2]) + xA - 2,
                        (alto / 2 - datosEntrada[3]) + yA - 2,
                        (ancho / 2 - datosEntrada[2]) + xB - 2,
                        (alto / 2 - datosEntrada[3]) + yB - 2);

                g.setColor(colorRuta3);
                g.drawLine(
                        (ancho / 2 - datosEntrada[2]) + xA + 2,
                        (alto / 2 - datosEntrada[3]) + yA + 2,
                        (ancho / 2 - datosEntrada[2]) + xB + 2,
                        (alto / 2 - datosEntrada[3]) + yB + 2);
            }
            g.setStroke(new BasicStroke(1.0f));
        }
    }

    private void paintPuntosInteres(Graphics g2) {
        Graphics2D g = (Graphics2D) g2;
        if (controlador.getMostrarPOI() && controlador.getListadoPOI() != null) {
            Vector poi = controlador.getListadoPOI().getListaPOI();
            for (int i = 0; i < poi.size(); i++) {
                int xA = (int) ((ElementoPOI) poi.elementAt(i)).getLatPixel();
                int yA = (int) ((ElementoPOI) poi.elementAt(i)).getLongPixel();
                Object aux = poi.elementAt(i);
                Image simbolo = dameImagenPOI((ElementoPOI) aux);
                if (((ElementoPOI) aux).getTipo().compareTo("Otro") == 0) {
                    g.drawImage(
                            simbolo,
                            (ancho / 2 - datosEntrada[2]) + xA - 25,
                            (alto / 2 - datosEntrada[3]) + yA - 45,
                            null);
                } else {
                    g.drawImage(
                            simbolo,
                            (ancho / 2 - datosEntrada[2]) + xA - 17,
                            (alto / 2 - datosEntrada[3]) + yA - 37,
                            null);
                }
                if (((ElementoPOI) aux).isSeleccionado()) {
                    g.setStroke(new BasicStroke(3.0f));

                    //Triangulo

                    int[] x = new int[3];
                    x[0] = (ancho / 2 - datosEntrada[2]) + xA + 3;
                    x[1] = (ancho / 2 - datosEntrada[2]) + xA + 15;
                    x[2] = (ancho / 2 - datosEntrada[2]) + xA + 5;
                    int[] y = new int[3];
                    y[0] = (alto / 2 - datosEntrada[3]) + yA + 6;
                    y[1] = (alto / 2 - datosEntrada[3]) + yA + 20;
                    y[2] = (alto / 2 - datosEntrada[3]) + yA + 25;
                    g.setColor(Color.RED);
                    g.fillPolygon(x, y, 3);
                    g.setColor(Color.BLACK);
                    g.drawPolygon(x, y, 3);


                    //Flecha
                    /*g.setColor(Color.RED);
                    g.drawLine(
                    (ancho / 2 - datosEntrada[2]) + xA + 10,
                    (alto / 2 - datosEntrada[3]) + yA,
                    (ancho / 2 - datosEntrada[2]) + xA,
                    (alto / 2 - datosEntrada[3]) + yA);
                    g.drawLine(
                    (ancho / 2 - datosEntrada[2]) + xA,
                    (alto / 2 - datosEntrada[3]) + yA + 10,
                    (ancho / 2 - datosEntrada[2]) + xA,
                    (alto / 2 - datosEntrada[3]) + yA);
                    g.drawLine(
                    (ancho / 2 - datosEntrada[2]) + xA + 15,
                    (alto / 2 - datosEntrada[3]) + yA + 15,
                    (ancho / 2 - datosEntrada[2]) + xA,
                    (alto / 2 - datosEntrada[3]) + yA);
                     */
                    /*
                    g.drawRect(
                    (ancho / 2 - datosEntrada[2]) + xA,
                    (alto / 2 - datosEntrada[3]) + yA,
                    10, 10);
                    g.fillRect(
                    (ancho / 2 - datosEntrada[2]) + xA,
                    (alto / 2 - datosEntrada[3]) + yA,
                    10, 10);
                     */
                    g.setStroke(new BasicStroke(1.0f));
                }
            }
        }
    }

    public void paintBorder(Component c, Graphics g, int x, int y, int width, int height) {
        //null = controlador.getnull();
        ancho = ancho;
        alto = alto;

        //Si las coordenadas son validas
        if ((coordenadas.getLatitud() != -1) && (coordenadas.getLongitud() != -1) && (coordenadas.getAltitud() != 777)) {
            //Primero pintamos un fondo por defecto para que se vea detras de
            //los mapas por si hubiese algun problema.
            paintNotFound(g);
            if (controlador.getModoMapas()) {
                paintMapasGoogle(g);
            } else {
                paintMapasMemoria(g);
            }

            if (controlador.getVectorRuta() != null) {
                paintRuta(g);
            }
            if (controlador.getMostrarPOI()) {
                paintPuntosInteres(g);
            }

            if (controlador.getVectorRuta() != null) {
                paintRuta(g);
            }

            //Cambiamos el color y dibujamos el punto del centro de la pantalla
            //que determina nuestra posicion actual
            g.setColor(new Color(0, 70, 180));
            g.fillArc(ancho / 2 - 5, alto / 2 - 5, 10, 10, 0, 360);
            g.setColor(new Color(255, 255, 255));
            g.drawArc(ancho / 2 - 6, alto / 2 - 6, 10, 10, 0, 360);
        } else {
            paintNotFound(g);
        }
    }

    public Insets getBorderInsets(Component c) {
        return new Insets(0, 0, 0, 0);
    }

    public boolean isBorderOpaque() {
        return true;
    }

    public void setSumaLatLong(double lat, double longi) {
        coordenadas.setLatitud(coordenadas.getLatitud() + lat);
        coordenadas.setLongitud(coordenadas.getLongitud() + longi);
    }

    /**
     * @return the nivelZoom
     */
    public int getNivelZoom() {
        return nivelZoom;
    }

    /**
     * @param nivelZoom the nivelZoom to set
     */
    public void setNivelZoom(int nivelZoom) {
        this.nivelZoom = nivelZoom;
    }

    public void setEscala(double e) {
        escala = e;
    }

    public double getEscala() {
        return escala;
    }

    public double getLatitud() {
        return latitudActual;
    }

    public double getLongitud() {
        return longitudActual;
    }

    public double getVelocidad() {
        return velocidad;
    }

    public double getDistancia() {
        return distancia;
    }

    public String getMapType() {
        return mapType;
    }

    public void setMapType(String s) {
        mapType = s;
    }

    private void inicializarValores() {
        controlador = Inicio.getControlador();
        ancho = controlador.getAnchoPantalla();
        alto = controlador.getAltoPantalla();
        distancia = 0;
        datosEntrada = new int[4];
        datosEntrada[2] = 0;
        datosEntrada[3] = 0;
        coordenadas = new FicheroDatos();
        despX = 0;
        despY = 0;
        googlemaps = new GoogleMaps(controlador.getCuentaGoogle());
        escala = 0.91743119266055045871559633027523;
        nivelZoom = 17;
        mapType = "roadmap";
        colorRuta1 = Color.RED;
        colorRuta2 = Color.GREEN;
        colorRuta3 = Color.RED;
    }

    private Image dameImagenPOI(ElementoPOI poi_element) {
        if (poi_element.getTipo().compareTo("Cafeteria") == 0) {
            return (Toolkit.getDefaultToolkit().getImage(
                    getClass().getResource("/Archivos/ImagenesPOI/poiCoffee.png")));
        } else if (poi_element.getTipo().compareTo("Restaurante") == 0) {
            return (Toolkit.getDefaultToolkit().getImage(
                    getClass().getResource("/Archivos/ImagenesPOI/poiRestaurant.png")));
        } else if (poi_element.getTipo().compareTo("Gasolinera") == 0) {
            return (Toolkit.getDefaultToolkit().getImage(
                    getClass().getResource("/Archivos/ImagenesPOI/poiGazstation.png")));
        } else if (poi_element.getTipo().compareTo("Direccion") == 0) {
            return (Toolkit.getDefaultToolkit().getImage(
                    getClass().getResource("/Archivos/ImagenesPOI/poiHome.png")));
        } else if (poi_element.getTipo().compareTo("Hostel") == 0) {
            return (Toolkit.getDefaultToolkit().getImage(
                    getClass().getResource("/Archivos/ImagenesPOI/poiHostel.png")));
        } else if (poi_element.getTipo().compareTo("Parking") == 0) {
            return (Toolkit.getDefaultToolkit().getImage(
                    getClass().getResource("/Archivos/ImagenesPOI/poiParking.png")));
        } else if (poi_element.getTipo().compareTo("Primeros auxilios") == 0) {
            return (Toolkit.getDefaultToolkit().getImage(
                    getClass().getResource("/Archivos/ImagenesPOI/poiFirstaid.png")));
        } else if (poi_element.getTipo().compareTo("Servicios") == 0) {
            return (Toolkit.getDefaultToolkit().getImage(
                    getClass().getResource("/Archivos/ImagenesPOI/poiToilets.png")));
        } else {
            return (Toolkit.getDefaultToolkit().getImage(
                    getClass().getResource("/Archivos/ImagenesPOI/poiDefault.png")));
        }
    }

    public ElementoGmaps[][] getMapaActual() {
        if (matrizGMaps != null) {
            return matrizGMaps;
        }
        if (matrizMemoria != null) {
            return matrizMemoria;
        }
        return null;
    }

    public void limpiaMatrizMemoria() {
        matrizMemoria = null;
    }
}




